/***********************************************************************

  A JavaScript tokenizer / parser / beautifier / compressor.

  This version is suitable for Node.js.  With minimal changes (the
  exports stuff) it should work on any JS platform.

  This file contains the tokenizer/parser.  It is a port to JavaScript
  of parse-js [1], a JavaScript parser library written in Common Lisp
  by Marijn Haverbeke.  Thank you Marijn!

  [1] http://marijn.haverbeke.nl/parse-js/

  Exported functions:

    - tokenizer(code) -- returns a function.  Call the returned
      function to fetch the next token.

    - parse(code) -- returns an AST of the given JavaScript code.

  -------------------------------- (C) ---------------------------------

                           Author: Mihai Bazon
                         <mihai.bazon@gmail.com>
                       http://mihai.bazon.net/blog

  Distributed under the same terms as the original code (ZLIB license):

    Copyright 2010 (c) Mihai Bazon <mihai.bazon@gmail.com>
    Based on parse-js (http://marijn.haverbeke.nl/parse-js/).

    This software is provided 'as-is', without any express or implied
    warranty. In no event will the authors be held liable for any
    damages arising from the use of this software.

    Permission is granted to anyone to use this software for any
    purpose, including commercial applications, and to alter it and
    redistribute it freely, subject to the following restrictions:

    1. The origin of this software must not be misrepresented; you must
       not claim that you wrote the original software. If you use this
       software in a product, an acknowledgment in the product
       documentation would be appreciated but is not required.

    2. Altered source versions must be plainly marked as such, and must
       not be misrepresented as being the original software.

    3. This notice may not be removed or altered from any source
       distribution.

 ***********************************************************************/

var $C = require("./constants");

var make_deep_copy = $C.make_deep_copy;

var parse_js_number = (function(){
        var RE_HEX_NUMBER = /^0x[0-9a-f]+$/i;
        var RE_OCT_NUMBER = /^0[0-7]+$/;
        var RE_DEC_NUMBER = /^\d*\.?\d*(?:e-?\d*(?:\d\.?|\.?\d)\d*)?$/i;
        return function(num) {
                if (RE_HEX_NUMBER.test(num)) {
                        return parseInt(num.substr(2), 16);
                } else if (RE_OCT_NUMBER.test(num)) {
                        return parseInt(num.substr(1), 8);
                } else if (RE_DEC_NUMBER.test(num)) {
                        return parseFloat(num);
                }
        };
})();

function js_error(message, line, col, pos) {
        var err = new Error(message);
        err.type = "ParseJS";
        err.line = line;
        err.col = col;
        err.pos = pos;
        err.toString = function() {
                return message + "\nline: " + line + "\ncol: " + col + "\npos: " + pos;
        };
        throw err;
};

function is_token(token, type, val) {
        return token.type == type && (val == null || token.value == val);
};

var EX_EOF = {};

function ParseJS(){

// import stuff we need.

var ASSIGNMENT                 = make_deep_copy($C.ASSIGNMENT);
var ATOMIC_START_TOKEN         = make_deep_copy($C.ATOMIC_START_TOKEN);
var HOP                        = make_deep_copy($C.HOP);
var KEYWORDS                   = make_deep_copy($C.KEYWORDS);
var KEYWORDS_ATOM              = make_deep_copy($C.KEYWORDS_ATOM);
var KEYWORDS_BEFORE_EXPRESSION = make_deep_copy($C.KEYWORDS_BEFORE_EXPRESSION);
var OPERATORS                  = make_deep_copy($C.OPERATORS);
var OPERATOR_CHARS             = make_deep_copy($C.OPERATOR_CHARS);
var PRECEDENCE                 = make_deep_copy($C.PRECEDENCE);
var PUNC_BEFORE_EXPRESSION     = make_deep_copy($C.PUNC_BEFORE_EXPRESSION);
var PUNC_CHARS                 = make_deep_copy($C.PUNC_CHARS);
var REGEXP_MODIFIERS           = make_deep_copy($C.REGEXP_MODIFIERS);
var STATEMENTS_WITH_LABELS     = make_deep_copy($C.STATEMENTS_WITH_LABELS);
var UNARY_POSTFIX              = make_deep_copy($C.UNARY_POSTFIX);
var UNARY_PREFIX               = make_deep_copy($C.UNARY_PREFIX);
var WHITESPACE_CHARS           = make_deep_copy($C.WHITESPACE_CHARS);
var RESERVED_WORDS             = make_deep_copy($C.RESERVED_WORDS);
var curry                      = make_deep_copy($C.curry);
var is_alphanumeric_char       = make_deep_copy($C.is_alphanumeric_char);
var is_digit                   = make_deep_copy($C.is_digit);
var is_identifier_char         = make_deep_copy($C.is_identifier_char);
var member                     = make_deep_copy($C.member);
var prog1                      = make_deep_copy($C.prog1);
var slice                      = make_deep_copy($C.slice);

// isn't CommonJS great?

var CUSTOM_STATEMENT_PARSERS = {};
var CUSTOM_CALL_PARSERS = {};
var CUSTOM_TOKEN_READER = {};
var CUSTOM_TOKEN_PROCESSOR = null;

/* -----[ Tokenizer ]----- */

function tokenizer($TEXT, skip_comments) {

        var S = {
                text           : $TEXT.replace(/\r\n?|[\n\u2028\u2029]/g, "\n"),
                pos            : 0,
                tokpos         : 0,
                line           : 0,
                tokline        : 0,
                col            : 0,
                tokcol         : 0,
                newline_before : false,
                regex_allowed  : false
        };

        function peek() { return S.text.charAt(S.pos); };

        function next(signal_eof) {
                var ch = S.text.charAt(S.pos++);
                if (signal_eof && !ch)
                        throw EX_EOF;
                if (ch == "\n") {
                        S.newline_before = true;
                        ++S.line;
                        S.col = 0;
                } else {
                        ++S.col;
                }
                return ch;
        };

        function find(what, signal_eof) {
                var pos = S.text.indexOf(what, S.pos);
                if (signal_eof && pos == -1) throw EX_EOF;
                return pos;
        };

        function start_token() {
                S.tokline = S.line;
                S.tokcol = S.col;
                S.tokpos = S.pos;
        };

        function token(type, value) {
                S.regex_allowed = ((type == "operator" && !HOP(UNARY_POSTFIX, value)) ||
                                   (type == "keyword" && HOP(KEYWORDS_BEFORE_EXPRESSION, value)) ||
                                   (type == "punc" && HOP(PUNC_BEFORE_EXPRESSION, value)));
                var ret = {
                        type  : type,
                        value : value,
                        line  : S.tokline,
                        col   : S.tokcol,
                        pos   : S.tokpos,
                        nlb   : S.newline_before
                };
                S.newline_before = false;
                return ret;
        };

        function skip_whitespace() {
                while (HOP(WHITESPACE_CHARS, peek()))
                        next();
        };

        function read_while(pred) {
                var ret = "", ch = peek(), i = 0;
                while (ch && pred(ch, i++)) {
                        ret += next();
                        ch = peek();
                }
                return ret;
        };

        function parse_error(err) {
                js_error(err, S.tokline, S.tokcol, S.tokpos);
        };

        function read_num(prefix) {
                var has_e = false, after_e = false, has_x = false;
                var num = read_while(function(ch, i){
                        if (ch == "x" || ch == "X") {
                                if (has_x) return false;
                                return has_x = true;
                        }
                        if (!has_x && (ch == "E" || ch == "e")) {
                                if (has_e) return false;
                                return has_e = after_e = true;
                        }
                        if (ch == "-") {
                                if (after_e || (i == 0 && !prefix)) return true;
                                return false;
                        }
                        after_e = false;
                        return is_alphanumeric_char(ch) || ch == ".";
                });
                if (prefix)
                        num = prefix + num;
                var valid = parse_js_number(num);
                if (!isNaN(valid)) {
                        return token("num", valid);
                } else {
                        parse_error("Invalid syntax: " + num);
                }
        };

        function read_escaped_char() {
                var ch = next(true);
                switch (ch) {
                    case "n" : return "\n";
                    case "r" : return "\r";
                    case "t" : return "\t";
                    case "b" : return "\b";
                    case "v" : return "\v";
                    case "f" : return "\f";
                    case "0" : return "\0";
                    case "x" : return String.fromCharCode(hex_bytes(2));
                    case "u" : return String.fromCharCode(hex_bytes(4));
                    default  : return ch;
                }
        };

        function hex_bytes(n) {
                var num = 0;
                for (; n > 0; --n) {
                        var digit = parseInt(next(true), 16);
                        if (isNaN(digit))
                                parse_error("Invalid hex-character pattern in string");
                        num = (num << 4) | digit;
                }
                return num;
        };

        function read_string() {
                return with_eof_error("Unterminated string constant", function(){
                        var quote = next(), ret = "";
                        for (;;) {
                                var ch = next(true);
                                if (ch == "\\") ch = read_escaped_char();
                                else if (ch == quote) break;
                                ret += ch;
                        }
                        return token("string", ret);
                });
        };

        function read_line_comment() {
                next();
                var i = find("\n"), ret;
                if (i == -1) {
                        ret = S.text.substr(S.pos);
                        S.pos = S.text.length;
                } else {
                        ret = S.text.substring(S.pos, i);
                        S.pos = i;
                }
                return token("comment1", ret);
        };

        function read_multiline_comment() {
                next();
                return with_eof_error("Unterminated multiline comment", function(){
                        var i = find("*/", true),
                            text = S.text.substring(S.pos, i),
                            tok = token("comment2", text);
                        S.pos = i + 2;
                        S.newline_before = text.indexOf("\n") >= 0;
                        return tok;
                });
        };

        function read_regexp() {
                return with_eof_error("Unterminated regular expression", function(){
                        var prev_backslash = false, regexp = "", ch, in_class = false;
                        while ((ch = next(true))) if (prev_backslash) {
                                regexp += "\\" + ch;
                                prev_backslash = false;
                        } else if (ch == "[") {
                                in_class = true;
                                regexp += ch;
                        } else if (ch == "]" && in_class) {
                                in_class = false;
                                regexp += ch;
                        } else if (ch == "/" && !in_class) {
                                break;
                        } else if (ch == "\\") {
                                prev_backslash = true;
                        } else {
                                regexp += ch;
                        }
                        var mods = read_while(function(ch){
                                return HOP(REGEXP_MODIFIERS, ch);
                        });
                        return token("regexp", [ regexp, mods ]);
                });
        };

        function read_operator(prefix) {
                function grow(op) {
                        var bigger = op + peek();
                        if (HOP(OPERATORS, bigger)) {
                                next();
                                return grow(bigger);
                        } else {
                                return op;
                        }
                };
                return token("operator", grow(prefix || next()));
        };

        var handle_slash = skip_comments ? function() {
                next();
                switch (peek()) {
                    case "/": read_line_comment(); return next_token();
                    case "*": read_multiline_comment(); return next_token();
                }
                return S.regex_allowed ? read_regexp() : read_operator("/");
        } : function() {
                next();
                switch (peek()) {
                    case "/": return read_line_comment();
                    case "*": return read_multiline_comment();
                }
                return S.regex_allowed ? read_regexp() : read_operator("/");
        };

        function handle_dot() {
                next();
                return is_digit(peek())
                        ? read_num(".")
                        : token("punc", ".");
        };

        function read_word() {
                var word = read_while(is_identifier_char);
                return !HOP(KEYWORDS, word)
                        ? token("name", word)
                        : HOP(OPERATORS, word)
                        ? token("operator", word)
                        : HOP(KEYWORDS_ATOM, word)
                        ? token("atom", word)
                        : token("keyword", word);
        };

        function with_eof_error(eof_error, cont) {
                try {
                        return cont();
                } catch(ex) {
                        if (ex === EX_EOF) parse_error(eof_error);
                        else throw ex;
                }
        };

        function next_token(force_regexp) {
                if (force_regexp)
                        return read_regexp();
                skip_whitespace();
                var ch = peek();
                if (CUSTOM_TOKEN_READER[ch])
                        return CUSTOM_TOKEN_READER[ch](tokenizer_context, obj_context);
                start_token();
                if (!ch) return token("eof");
                if (is_digit(ch)) return read_num();
                if (ch == '"' || ch == "'") return read_string();
                if (HOP(PUNC_CHARS, ch)) return token("punc", next());
                if (ch == ".") return handle_dot();
                if (ch == "/") return handle_slash();
                if (HOP(OPERATOR_CHARS, ch)) return read_operator();
                if (is_identifier_char(ch)) return read_word();
                parse_error("Unexpected character '" + ch + "'");
        };

        var tokenizer_context = {
                S                      : S,
                peek                   : peek,
                next                   : next,
                find                   : find,
                start_token            : start_token,
                token                  : token,
                skip_whitespace        : skip_whitespace,
                read_while             : read_while,
                parse_error            : parse_error,
                read_num               : read_num,
                read_escaped_char      : read_escaped_char,
                hex_bytes              : hex_bytes,
                read_string            : read_string,
                read_line_comment      : read_line_comment,
                read_multiline_comment : read_multiline_comment,
                read_regexp            : read_regexp,
                read_operator          : read_operator,
                handle_slash           : handle_slash,
                handle_dot             : handle_dot,
                read_word              : read_word,
                with_eof_error         : with_eof_error,
                next_token             : next_token,
                is_token               : is_token
        };

        next_token.context = function(nc) {
                if (nc) S = nc;
                return S;
        };

        return next_token;

};

/* -----[ Parser ]----- */

function parse($TEXT, strict_mode) {

        var S = {
                input: tokenizer($TEXT, true),
                token: null,
                prev: null,
                peeked: null,
                in_function: 0,
                in_loop: 0,
                labels: []
        };

        S.token = next();

        function tokprocess(cont) {
                return CUSTOM_TOKEN_PROCESSOR
                        ? CUSTOM_TOKEN_PROCESSOR(cont, parser_context, obj_context)
                        : cont();
        };

        function is(type, value) {
                return is_token(S.token, type, value);
        };

        function peek() { return S.peeked || (S.peeked = S.input()); };

        function next() {
                S.prev = S.token;
                if (S.peeked) {
                        S.token = S.peeked;
                        S.peeked = null;
                } else {
                        S.token = S.input();
                }
                return S.token;
        };

        function prev() {
                return S.prev;
        };

        function croak(msg, line, col, pos) {
                var ctx = S.input.context();
                js_error(msg,
                         line != null ? line : ctx.tokline,
                         col != null ? col : ctx.tokcol,
                         pos != null ? pos : ctx.tokpos);
        };

        function token_error(token, msg) {
                croak(msg, token.line, token.col);
        };

        function unexpected(token) {
                if (token == null)
                        token = S.token;
                token_error(token, "Unexpected token: " + token.type + " \"" + token.value + "\"");
        };

        function expect_token(type, val) {
                if (is(type, val)) {
                        return next();
                }
                token_error(S.token, "Unexpected token " + S.token.type + " \"" + S.token.value + "\", expected " + type + " \"" + val + "\"");
        };

        function expect(punc) { return expect_token("punc", punc); };

        function can_insert_semicolon() {
                return !strict_mode && (
                        S.token.nlb || is("eof") || is("punc", "}")
                );
        };

        function semicolon() {
                if (is("punc", ";")) next();
                else if (!can_insert_semicolon()) unexpected();
        };

        function as() {
                return make_node
                        ? make_node(parser_context, obj_context, slice(arguments))
                        : slice(arguments);
        };

        function parenthesised() {
                expect("(");
                var ex = expression();
                expect(")");
                return ex;
        };

        function statement() {
                if (is("operator", "/")) {
                        S.peeked = null;
                        S.token = S.input(true); // force regexp
                }
                switch (S.token.type) {
                    case "num":
                    case "string":
                    case "regexp":
                    case "operator":
                    case "atom":
                        return simple_statement();

                    case "name":
                        return is_token(peek(), "punc", ":")
                                ? labeled_statement(prog1(S.token.value, next, next))
                                : simple_statement();

                    case "punc":
                        switch (S.token.value) {
                            case "{":
                                return as("block", block_());
                            case "[":
                            case "(":
                                return simple_statement();
                            case ";":
                                next();
                                return as("block");
                        }
                        unexpected();

                    case "keyword":
                        var kw = prog1(S.token.value, next);
                        if (CUSTOM_STATEMENT_PARSERS[kw])
                                return CUSTOM_STATEMENT_PARSERS[kw](parser_context, obj_context);
                        switch (kw) {
                            case "break":
                                return break_cont("break");

                            case "continue":
                                return break_cont("continue");

                            case "debugger":
                                semicolon();
                                return as("debugger");

                            case "do":
                                return (function(body){
                                        expect_token("keyword", "while");
                                        return as("do", prog1(parenthesised, semicolon), body);
                                })(in_loop(statement));

                            case "for":
                                return for_();

                            case "function":
                                return function_(true);

                            case "if":
                                return if_();

                            case "return":
                                if (S.in_function == 0)
                                        croak("'return' outside of function");
                                return as("return",
                                          is("punc", ";")
                                          ? (next(), null)
                                          : can_insert_semicolon()
                                          ? null
                                          : prog1(expression, semicolon));

                            case "switch":
                                return as("switch", parenthesised(), switch_block_());

                            case "throw":
                                return as("throw", prog1(expression, semicolon));

                            case "try":
                                return try_();

                            case "var":
                                return prog1(var_, semicolon);

                            case "const":
                                return prog1(const_, semicolon);

                            case "while":
                                return as("while", parenthesised(), in_loop(statement));

                            case "with":
                                return as("with", parenthesised(), statement());

                            default:
                                unexpected();
                        }
                }
        };

        function labeled_statement(label) {
                S.labels.push(label);
                var start = S.token, stat = statement();
                if (strict_mode && !HOP(STATEMENTS_WITH_LABELS, stat[0]))
                        unexpected(start);
                S.labels.pop();
                return as("label", label, stat);
        };

        function simple_statement() {
                return as("stat", prog1(expression, semicolon));
        };

        function break_cont(type) {
                if (S.in_loop == 0)
                        croak(type + " not inside a loop or switch");
                var name = is("name") ? S.token.value : null;
                if (name != null) {
                        next();
                        if (!member(name, S.labels))
                                croak("Label " + name + " without matching loop or statement");
                }
                semicolon();
                return as(type, name);
        };

        function for_() {
                expect("(");
                var has_var = is("keyword", "var");
                if (has_var)
                        next();
                if (is("name") && is_token(peek(), "operator", "in")) {
                        // for (i in foo)
                        var name = S.token.value;
                        next(); next();
                        var obj = expression();
                        expect(")");
                        return as("for-in", has_var, name, obj, in_loop(statement));
                } else {
                        // classic for
                        var init = is("punc", ";") ? null : has_var ? var_() : expression();
                        expect(";");
                        var test = is("punc", ";") ? null : expression();
                        expect(";");
                        var step = is("punc", ")") ? null : expression();
                        expect(")");
                        return as("for", init, test, step, in_loop(statement));
                }
        };

        function function_(in_statement) {
                var name = is("name") ? tokprocess(curry(prog1, S.token.value, next)) : null;
                if (in_statement && !name)
                        unexpected();
                expect("(");
                return as(in_statement ? "defun" : "function",
                          name,
                          // arguments
                          (function(first, a){
                                  while (!is("punc", ")")) {
                                          if (first) first = false; else expect(",");
                                          if (!is("name")) unexpected();
                                          a.push(tokprocess(function() { return S.token.value }));
                                          next();
                                  }
                                  next();
                                  return a;
                          })(true, []),
                          // body
                          (function(){
                                  ++S.in_function;
                                  var a = block_();
                                  --S.in_function;
                                  return a;
                          })());
        };

        function if_() {
                var cond = parenthesised(), body = statement(), belse = null;
                if (is("keyword", "else")) {
                        next();
                        belse = statement();
                }
                return as("if", cond, body, belse);
        };

        function block_() {
                expect("{");
                var a = [];
                while (!is("punc", "}")) {
                        if (is("eof")) unexpected();
                        a.push(statement());
                }
                next();
                return a;
        };

        var switch_block_ = curry(in_loop, function(){
                expect("{");
                var a = [], cur = null;
                while (!is("punc", "}")) {
                        if (is("eof")) unexpected();
                        if (is("keyword", "case")) {
                                next();
                                cur = [];
                                a.push([ expression(), cur ]);
                                expect(":");
                        }
                        else if (is("keyword", "default")) {
                                next();
                                expect(":");
                                cur = [];
                                a.push([ null, cur ]);
                        }
                        else {
                                if (!cur) unexpected();
                                cur.push(statement());
                        }
                }
                next();
                return a;
        });

        function try_() {
                var body = block_(), bcatch, bfinally;
                if (is("keyword", "catch")) {
                        next();
                        expect("(");
                        var name = tokprocess(function(){
                                if (!is("name"))
                                        croak("Name expected");
                                return S.token.value;
                        });
                        next();
                        expect(")");
                        bcatch = [ name, block_() ];
                }
                if (is("keyword", "finally")) {
                        next();
                        bfinally = block_();
                }
                if (!bcatch && !bfinally)
                        croak("Missing catch/finally blocks");
                return as("try", body, bcatch, bfinally);
        };

        function vardefs() {
                var a = [];
                for (;;) {
                        if (!is("name"))
                                unexpected();
                        var name = tokprocess(function(){
                                if (!is("name"))
                                        unexpected();
                                return S.token.value;
                        });
                        next();
                        if (is("operator", "=")) {
                                next();
                                a.push([ name, expression(false) ]);
                        } else {
                                a.push([ name ]);
                        }
                        if (!is("punc", ","))
                                break;
                        next();
                }
                return a;
        };

        function var_() {
                return as("var", vardefs());
        };

        function const_() {
                return as("const", vardefs());
        };

        function new_() {
                var newexp = expr_atom(false), args;
                if (is("punc", "(")) {
                        next();
                        args = expr_list(")");
                } else {
                        args = [];
                }
                return subscripts(as("new", newexp, args), true);
        };

        function expr_atom(allow_calls) {
                if (is("operator", "new")) {
                        next();
                        return new_();
                }
                if (is("operator") && HOP(UNARY_PREFIX, S.token.value)) {
                        return make_unary("unary-prefix",
                                          prog1(S.token.value, next),
                                          expr_atom(allow_calls));
                }
                if (is("punc")) return tokprocess(function(){
                        switch (S.token.value) {
                            case "(":
                                next();
                                return subscripts(prog1(expression, curry(expect, ")")), allow_calls);
                            case "[":
                                next();
                                return subscripts(array_(), allow_calls);
                            case "{":
                                next();
                                return subscripts(object_(), allow_calls);
                        }
                        unexpected();
                });
                if (is("keyword", "function")) return tokprocess(function(){
                        next();
                        return subscripts(function_(false), allow_calls);
                });
                if (HOP(ATOMIC_START_TOKEN, S.token.type)) {
                        var atom = tokprocess(function(){
                                return S.token.type == "regexp"
                                        ? as("regexp", S.token.value[0], S.token.value[1])
                                        : as(S.token.type, S.token.value);
                        });
                        return subscripts(prog1(atom, next), allow_calls);
                }
                if (CUSTOM_TOKEN_PROCESSOR) {
                        return tokprocess(statement); // try to read as statement
                }
                unexpected();
        };

        function expr_list(closing, allow_trailing_comma) {
                var first = true, a = [];
                while (!is("punc", closing)) {
                        if (first) first = false; else expect(",");
                        if (allow_trailing_comma && is("punc", closing))
                                break;
                        a.push(expression(false));
                }
                next();
                return a;
        };

        function array_() {
                return as("array", expr_list("]", !strict_mode));
        };

        function object_() {
                var first = true, a = [];
                while (!is("punc", "}")) {
                        if (first) first = false; else expect(",");
                        if (!strict_mode && is("punc", "}"))
                                // allow trailing comma
                                break;
                        var name = as_property_name();
                        expect(":");
                        var value = expression(false);
                        a.push([ name, value ]);
                }
                next();
                return as("object", a);
        };

        function as_property_name() {
                switch (S.token.type) {
                    case "num":
                    case "string":
                        return tokprocess(curry(prog1, S.token.value, next));
                }
                return as_name();
        };

        function as_name() {
                return tokprocess(function(){
                        switch (S.token.type) {
                            case "name":
                            case "operator":
                            case "keyword":
                            case "atom":
                                return prog1(S.token.value, next);
                            default:
                                unexpected();
                        }
                });
        };

        function subscripts(expr, allow_calls) {
                if (is("punc", ".")) {
                        next();
                        return subscripts(as("dot", expr, as_name()), allow_calls);
                }
                if (is("punc", "[")) {
                        next();
                        return subscripts(as("sub", expr, prog1(expression, curry(expect, "]"))), allow_calls);
                }
                if (allow_calls && is("punc", "(")) {
                        if (expr[0] == "name" && CUSTOM_CALL_PARSERS[expr[1]]) {
                                return CUSTOM_CALL_PARSERS[expr[1]](parser_context, obj_context);
                        }
                        next();
                        return subscripts(as("call", expr, expr_list(")")), true);
                }
                if (allow_calls && is("operator") && HOP(UNARY_POSTFIX, S.token.value)) {
                        return prog1(curry(make_unary, "unary-postfix", S.token.value, expr),
                                     next);
                }
                return expr;
        };

        function make_unary(tag, op, expr) {
                if ((op == "++" || op == "--") && !is_assignable(expr))
                        croak("Invalid use of " + op + " operator");
                return as(tag, op, expr);
        };

        function expr_op(left, min_prec) {
                var op = is("operator") ? S.token.value : null;
                var prec = op != null ? PRECEDENCE[op] : null;
                if (prec != null && prec > min_prec) {
                        next();
                        var right = expr_op(expr_atom(true), prec);
                        return expr_op(as("binary", op, left, right), min_prec);
                }
                return left;
        };

        function expr_ops() {
                return expr_op(expr_atom(true), 0);
        };

        function maybe_conditional() {
                var expr = expr_ops();
                if (is("operator", "?")) {
                        next();
                        var yes = expression(false);
                        expect(":");
                        return as("conditional", expr, yes, expression(false));
                }
                return expr;
        };

        function is_assignable(expr) {
                // XXX: to support macro it's necessary not to check this
                return true;
                // expr = expr[0];
                // return expr == "name" || expr == "dot" || expr == "sub";
        };

        function maybe_assign() {
                var left = maybe_conditional(), val = S.token.value;
                if (is("operator") && HOP(ASSIGNMENT, val)) {
                        if (is_assignable(left)) {
                                next();
                                return as("assign", ASSIGNMENT[val], left, maybe_assign());
                        }
                        croak("Invalid assignment");
                }
                return left;
        };

        function expression(commas) {
                if (arguments.length == 0)
                        commas = true;
                var expr = maybe_assign();
                if (commas && is("punc", ",")) {
                        next();
                        return as("seq", expr, expression());
                }
                return expr;
        };

        function in_loop(cont) {
                ++S.in_loop;
                var ret = cont();
                --S.in_loop;
                return ret;
        };

        var parser_context = {
                S                 : S,
                is                : is,
                peek              : peek,
                next              : next,
                prev              : prev,
                croak             : croak,
                token_error       : token_error,
                unexpected        : unexpected,
                expect_token      : expect_token,
                expect            : expect,
                semicolon         : semicolon,
                as                : as,
                parenthesised     : parenthesised,
                statement         : statement,
                labeled_statement : labeled_statement,
                simple_statement  : simple_statement,
                break_cont        : break_cont,
                for_              : for_,
                function_         : function_,
                if_               : if_,
                block_            : block_,
                switch_block_     : switch_block_,
                try_              : try_,
                vardefs           : vardefs,
                var_              : var_,
                const_            : const_,
                new_              : new_,
                expr_atom         : expr_atom,
                expr_list         : expr_list,
                array_            : array_,
                object_           : object_,
                as_property_name  : as_property_name,
                as_name           : as_name,
                subscripts        : subscripts,
                make_unary        : make_unary,
                expr_op           : expr_op,
                expr_ops          : expr_ops,
                maybe_conditional : maybe_conditional,
                is_assignable     : is_assignable,
                maybe_assign      : maybe_assign,
                expression        : expression,
                in_loop           : in_loop,
                tokprocess        : tokprocess,
                token             : function() { return S.token },
                tokval            : function() { return S.token.value }
        };

        return as("toplevel", (function(a){
                while (!is("eof"))
                        a.push(statement());
                return a;
        })([]));

};

        // API

        var obj_context = {
                ASSIGNMENT                 : ASSIGNMENT,
                ATOMIC_START_TOKEN         : ATOMIC_START_TOKEN,
                HOP                        : HOP,
                KEYWORDS                   : KEYWORDS,
                KEYWORDS_ATOM              : KEYWORDS_ATOM,
                KEYWORDS_BEFORE_EXPRESSION : KEYWORDS_BEFORE_EXPRESSION,
                OPERATORS                  : OPERATORS,
                OPERATOR_CHARS             : OPERATOR_CHARS,
                PRECEDENCE                 : PRECEDENCE,
                PUNC_BEFORE_EXPRESSION     : PUNC_BEFORE_EXPRESSION,
                PUNC_CHARS                 : PUNC_CHARS,
                REGEXP_MODIFIERS           : REGEXP_MODIFIERS,
                STATEMENTS_WITH_LABELS     : STATEMENTS_WITH_LABELS,
                UNARY_POSTFIX              : UNARY_POSTFIX,
                UNARY_PREFIX               : UNARY_PREFIX,
                WHITESPACE_CHARS           : WHITESPACE_CHARS,
                RESERVED_WORDS             : RESERVED_WORDS,
                curry                      : curry,
                is_alphanumeric_char       : is_alphanumeric_char,
                is_digit                   : is_digit,
                member                     : member,
                prog1                      : prog1,
                slice                      : slice,

                self: this,
                tokenizer: tokenizer,
                parse: parse
        };

        var make_node = null;

        this.tokenizer = tokenizer;
        this.parse = parse;

        this.define_keyword = function(kw) {
                KEYWORDS[kw] = kw;
                RESERVED_WORDS[kw] = kw;
        };

        this.define_call_parser = function(name, parser) {
                CUSTOM_CALL_PARSERS[name] = parser;
        };

        this.define_statement = function(kw, parser) {
                this.define_keyword(kw);
                CUSTOM_STATEMENT_PARSERS[kw] = parser;
        };

        this.define_mknode = function(func) {
                make_node = func;
        };

        this.define_token_reader = function(ch, reader) {
                CUSTOM_TOKEN_READER[ch] = reader;
        };

        this.define_token_processor = function(func) {
                CUSTOM_TOKEN_PROCESSOR = func;
        };

};

/* -----[ Exports ]----- */

exports.ParseJS = ParseJS;

// support old API
(function(P){
        exports.tokenizer = P.tokenizer;
        exports.parse = P.parse;
})(new ParseJS());
